//n 座城市，从 0 到 n-1 编号，其间共有 n-1 条路线。因此，要想在两座不同城市之间旅行只有唯一一条路线可供选择（路线网形成一颗树）。去年，交通运输
//部决定重新规划路线，以改变交通拥堵的状况。 
//
// 路线用 connections 表示，其中 connections[i] = [a, b] 表示从城市 a 到 b 的一条有向路线。 
//
// 今年，城市 0 将会举办一场大型比赛，很多游客都想前往城市 0 。 
//
// 请你帮助重新规划路线方向，使每个城市都可以访问城市 0 。返回需要变更方向的最小路线数。 
//
// 题目数据 保证 每个城市在重新规划路线方向后都能到达城市 0 。 
//
// 
//
// 示例 1： 
//
// 
//
// 输入：n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]
//输出：3
//解释：更改以红色显示的路线的方向，使每个城市都可以到达城市 0 。 
//
// 示例 2： 
//
// 
//
// 输入：n = 5, connections = [[1,0],[1,2],[3,2],[3,4]]
//输出：2
//解释：更改以红色显示的路线的方向，使每个城市都可以到达城市 0 。 
//
// 示例 3： 
//
// 输入：n = 3, connections = [[1,0],[2,0]]
//输出：0
// 
//
// 
//
// 提示： 
//
// 
// 2 <= n <= 5 * 10^4 
// connections.length == n-1 
// connections[i].length == 2 
// 0 <= connections[i][0], connections[i][1] <= n-1 
// connections[i][0] != connections[i][1] 
// 
// Related Topics深度优先搜索 | 广度优先搜索 | 图 
//
// 👍 86, 👎 0 
//
//
//
//

package leetcode.editor.cn;

import javafx.util.Pair;

import java.util.LinkedList;
import java.util.Queue;

class ReorderRoutesToMakeAllPathsLeadToTheCityZero {
    public static void main(String[] args) {
        Solution solution = new ReorderRoutesToMakeAllPathsLeadToTheCityZero().new Solution();
    }

    //leetcode submit region begin(Prohibit modification and deletion)
    // https://leetcode.cn/problems/reorder-routes-to-make-all-paths-lead-to-the-city-zero/solution/c-by-lzyer-0fo9/
    class Solution {
        // BFS：逆向思维，从0开始遍历，如果遍历的边是逆向的，那么就加一
        public int minReorder(int n, int[][] connections) {
            LinkedList<Pair<Integer, Integer>>[] graph = new LinkedList[n];
            for (int i = 0; i < n; i++) {
                graph[i] = new LinkedList<>();
            }

            // 建图，注意这里建的是无向图，使用0和1来标识是逆向还是正向
            for (int[] connection : connections) {
                // 正向
                graph[connection[0]].add(new Pair<>(connection[1], 1));
                // 逆向
                graph[connection[1]].add(new Pair<>(connection[0], 0));
            }

            // 从0开始遍历 (ps：DFS遍历也一样)
            Queue<Integer> queue = new LinkedList<>();
            queue.offer(0);
            // 由于建了无向图，防止走回头路
            boolean[] visited = new boolean[n];
            visited[0] = true;
            int ans = 0;
            while (!queue.isEmpty()) {
                int cur = queue.poll();
                for (Pair<Integer, Integer> pair : graph[cur]) {
                    int next = pair.getKey();
                    if (!visited[next]) {
                        // 判断是否是正向，如果是正向，那么就需要改变这一条路径
                        ans += pair.getValue();
                        visited[next] = true;
                        queue.offer(next);
                    }
                }
            }

            return ans;
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

}
